home *** CD-ROM | disk | FTP | other *** search
/ CDUTIL 13 / CDUTIL #13 Julio 1995.iso / windows / acadwin / ads / cpp / general / adsstrng.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-08  |  14.9 KB  |  448 lines
  1. /* 
  2.     ADSSTRNG.H -
  3.     
  4.     This file:
  5.  
  6.         Declares ADS_STRING.  This may seems excessive given
  7.         most compilers supply their version of CString, 
  8.         But unfortunately some major compiler vendor exclude CString
  9.         from their stand C++ library.
  10.  
  11.     (C) Copyright 1988-1994 by Autodesk, Inc.
  12.  
  13.     This program is copyrighted by Autodesk, Inc. and is  licensed
  14.     to you under the following conditions.  You may not distribute
  15.     or  publish the source code of this program in any form.   You
  16.     may  incorporate this code in object form in derivative  works
  17.     provided  such  derivative  works  are  (i.) are  designed and
  18.     intended  to  work  solely  with  Autodesk, Inc. products, and
  19.     (ii.)  contain  Autodesk's  copyright  notice  "(C)  Copyright
  20.     1988-1994 by Autodesk, Inc."
  21.  
  22.     AUTODESK  PROVIDES THIS PROGRAM "AS IS" AND WITH  ALL  FAULTS.
  23.     AUTODESK  SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF  MER-
  24.     CHANTABILITY OR FITNESS FOR A PARTICULAR USE.  AUTODESK,  INC.
  25.     DOES  NOT  WARRANT THAT THE OPERATION OF THE PROGRAM  WILL  BE
  26.     UNINTERRUPTED OR ERROR FREE.
  27.  
  28. */
  29. #ifndef __ADSSTRNG_H
  30. #define __ADSSTRNG_H
  31.  
  32. //-----------------------------------------------------------------------------
  33. class   ADS_REFERENCE;
  34. class   STRING_REF;
  35. struct  ADS_STRING;
  36.  
  37. //-----------------------------------------------------------------------------
  38. const size_t NPOS = size_t(-1);
  39.  
  40. /******************************************************************************
  41. *                                                                             *
  42. *                            ADS_STRING class                                 *
  43. *    This class is used because the standard CString class is not available   *
  44. *    among all the compilers and platform.  Under MS, using CString requires  *
  45. *    MFC. Note: This is NOT a COMPLETE CString class!!!                       *
  46. *                                                                             *
  47. ******************************************************************************/
  48. struct ADS_STRING : ADS_OBJ
  49. {   
  50.     //
  51.     // constructors
  52.     //
  53.                         ADS_STRING();
  54.                         ADS_STRING( const ADS_STRING& );
  55.                         ADS_STRING( const ADS_STRING& s, const char *cp );
  56.                         ADS_STRING( const char *cp );
  57.     // destrcutor
  58.     virtual             ~ADS_STRING();
  59.  
  60.     //
  61.     // Assignment
  62.     //
  63.     ADS_STRING&         operator = ( const ADS_STRING& );
  64.     ADS_STRING&         Assign( const ADS_STRING  &s );
  65.     ADS_STRING&         Assign( const ADS_STRING  &s, size_t orign, size_t n );
  66.  
  67.     //
  68.     // Comparision
  69.     //
  70.     int                 Compare(const ADS_STRING  &s) const;
  71.  
  72.     friend int   operator == ( const char  *cp, const ADS_STRING  &s );
  73.     friend int   operator == ( const ADS_STRING  &s1, const ADS_STRING  &s2 );
  74.     friend int   operator == ( const ADS_STRING  &s, const char  *cp );
  75.  
  76.     friend int   operator != ( const char  *cp, const ADS_STRING  &s );
  77.     friend int   operator != ( const ADS_STRING  &s1, const ADS_STRING  &s2 );
  78.     friend int   operator != ( const ADS_STRING  &s, const char  *cp );
  79.  
  80.     friend int   operator <  ( const ADS_STRING  &s1, const ADS_STRING  &s2 );
  81.     friend int   operator <  ( const ADS_STRING  &s, const char  *cp );
  82.     friend int   operator <  ( const char  *cp, const ADS_STRING  &s );
  83.  
  84.     friend int   operator <= ( const ADS_STRING  &s1, const ADS_STRING  &s2 );
  85.     friend int   operator <= ( const ADS_STRING  &s, const char  *cp );
  86.     friend int   operator <= ( const char  *cp, const ADS_STRING  &s );
  87.  
  88.     friend int   operator >  ( const ADS_STRING  &s1, const ADS_STRING  &s2 );
  89.     friend int   operator >  ( const ADS_STRING  &s, const char  *cp );
  90.     friend int   operator >  ( const char  *cp, const ADS_STRING  &s );
  91.  
  92.     friend int   operator >= ( const ADS_STRING  &s1, const ADS_STRING  &s2 );
  93.     friend int   operator >= ( const ADS_STRING  &s, const char  *cp );
  94.     friend int   operator >= ( const char  *cp, const ADS_STRING  &s );
  95.  
  96.     //
  97.     // Concatenation
  98.     //
  99.     ADS_STRING&         Append( const ADS_STRING   &s );
  100.     ADS_STRING&         Append( const char   *cp );
  101.     ADS_STRING&         Append( const ADS_STRING &s
  102.                                 , size_t orig
  103.                                 , size_t n = NPOS );
  104.  
  105.     ADS_STRING&         operator += ( const char *cp );
  106.     ADS_STRING&         operator += ( const ADS_STRING   &s );
  107.  
  108.     friend ADS_STRING   operator + ( const ADS_STRING &s, const char *cp );
  109.     friend ADS_STRING   operator + ( const ADS_STRING &s, const ADS_STRING &d );
  110.  
  111.     //
  112.     // Subscripting
  113.     //
  114.     char                GetAt( size_t pos );
  115.     void                PutAt( size_t pos, char c );
  116.  
  117.     char&               operator[]( size_t pos ) ;
  118.     char&               operator()( size_t pos ) ;
  119.  
  120.     //
  121.     // Searching
  122.     //
  123.     size_t              Find( const ADS_STRING  &s ) const;
  124.     size_t              Find( const ADS_STRING  &s, size_t pos ) const;
  125.     size_t              Rfind( const ADS_STRING  &s ) const;
  126.     size_t              Rfind( const ADS_STRING  &s, size_t pos ) const;
  127.  
  128.     int                 Contains( const char  *pat ) const;
  129.     int                 Contains( const ADS_STRING  &s ) const;
  130.  
  131.     //
  132.     // Character set searching
  133.     //
  134.     size_t              FindFirstOf( const ADS_STRING &s ) const;
  135.     size_t              FindFirstOf( const ADS_STRING &s, size_t pos ) const;
  136.     size_t              FindLastOf( const ADS_STRING &s ) const;
  137.     size_t              FindLastOf( const ADS_STRING &s, size_t pos ) const;
  138.  
  139.     //
  140.     // Miscellaneous
  141.     //
  142.     size_t              Length() const;
  143.     size_t              Copy( char *cb, size_t n );
  144.     size_t              Copy( char *cb, size_t n, size_t pos );
  145.     const char*         CString() const;
  146.     static size_t       GetInitialCapacity();
  147.     static size_t       GetResizeIncrement();
  148.     static size_t       GetMaxWaste();
  149.  
  150.     void                CopyOnWrite();
  151.     void                Clone();
  152.  
  153.  
  154.     virtual BOOL        Valid();
  155.     virtual void WhoAmI( char *buf )
  156.     {
  157.         if ( buf )
  158.             strcpy( buf, "ADS_STRING" );
  159.     }
  160.  
  161.     static size_t       initial_capac;
  162.     static size_t       resize_inc;
  163.     static size_t       max_waste;
  164.  
  165. private:
  166.     STRING_REF         *p;
  167. };
  168.  
  169. //-----------------------------------------------------------------------------
  170. //      Related global functions
  171. //
  172. istream&    operator >> ( istream &is, ADS_STRING &s );
  173. ostream&    operator << ( ostream &os, const ADS_STRING &s );
  174.  
  175. /******************************************************************************
  176. *                                                                             *
  177. *                          ADS_REFERENCE                                      *
  178. *                                                                             *
  179. ******************************************************************************/
  180. class ADS_REFERENCE : ADS_OBJ
  181. {
  182. public:
  183.  
  184.                         ADS_REFERENCE( size_t initRef = 0 )
  185.                                     : refs( initRef ) 
  186.                         { }
  187.     void                AddReference() 
  188.                         { 
  189.                             refs++; 
  190.                         }
  191.     size_t              References() 
  192.                         { 
  193.                             return refs; 
  194.                         }
  195.     size_t              RemoveReference() 
  196.                         { 
  197.                             return --refs; 
  198.                         }
  199.     virtual BOOL        Valid()
  200.                         { 
  201.                             return TRUE;
  202.                         }
  203.  
  204. private:
  205.     size_t refs;
  206. private:
  207.     BASIC_CPP_STUFF(ADS_REFERENCE)
  208. };
  209.  
  210. /******************************************************************************
  211. *                                                                             *
  212. *                            STRING_REF                                       *
  213. *                                                                             *
  214. ******************************************************************************/
  215. class STRING_REF : ADS_REFERENCE
  216. {
  217.     friend struct ADS_STRING;
  218.  
  219.     //
  220.     // Data
  221.     //
  222.     char            *array;
  223.     size_t          nchars;
  224.     size_t          capacity;
  225.  
  226.     //
  227.     // Constructors
  228.     //
  229.                     STRING_REF( const char *str1
  230.                             , size_t count1
  231.                             , const char *str2
  232.                             , size_t count2
  233.                             , size_t extra );
  234.     //
  235.     // Destructor
  236.     //
  237.                     ~STRING_REF();
  238.  
  239.     //
  240.     // Miscellaneous
  241.     //
  242.     void            GrowTo( size_t n );
  243.     size_t          RoundCapacity( size_t nc );
  244.     void            Splice( size_t start
  245.                             , size_t extent
  246.                             , const char *cp
  247.                             , size_t n );
  248.  
  249. private:
  250.     BASIC_CPP_STUFF(STRING_REF)
  251. };
  252.  
  253.  
  254. /******************************************************************************
  255. *                                                                             *
  256. *           INLINES for STRING_REF, ADS_REF, and ADS_STRING                   *
  257. *                                                                             *
  258. ******************************************************************************/
  259. //-----------------------------------------------------------------------------
  260. //
  261. //                          ADS_STRING
  262. //
  263. //-----------------------------------------------------------------------------
  264. inline ADS_STRING::~ADS_STRING()
  265. {
  266.     if ( p->RemoveReference() == 0 )
  267.     {
  268.         delete p;
  269.     }
  270. }
  271.  
  272. //-----------------------------------------------------------------------------
  273. inline ADS_STRING::ADS_STRING( const ADS_STRING& src )
  274. {
  275.     p = src.p;
  276.     p->AddReference();
  277. }
  278.  
  279. //-----------------------------------------------------------------------------
  280. inline ADS_STRING::ADS_STRING( const char *cp )
  281. {
  282.     p = new STRING_REF( cp, cp?strlen( cp ):0, 0, 0, 0 );
  283. }
  284.  
  285. //-----------------------------------------------------------------------------
  286. inline int ADS_STRING::Compare(const ADS_STRING  &s) const
  287. {
  288.     return strcmp( CString(), s.CString() );
  289. }
  290.  
  291. //-----------------------------------------------------------------------------
  292. inline ADS_STRING::ADS_STRING()
  293. {
  294.     p = new STRING_REF( NULL, 0, 0, 0, ADS_STRING::GetInitialCapacity() );
  295. }
  296.  
  297. //-----------------------------------------------------------------------------
  298. inline ADS_STRING::ADS_STRING( const ADS_STRING& s, const char *cp )
  299. {
  300.     p = new STRING_REF( s.CString(), s.Length(), cp, cp?strlen(cp):0, 0 );
  301. }
  302.  
  303. //-----------------------------------------------------------------------------
  304. inline size_t ADS_STRING::GetInitialCapacity()
  305. {
  306.     return initial_capac;
  307. }
  308.  
  309. //-----------------------------------------------------------------------------
  310. inline size_t ADS_STRING::GetResizeIncrement()
  311. {
  312.     return resize_inc;
  313. }
  314.  
  315. //-----------------------------------------------------------------------------
  316. inline size_t ADS_STRING::GetMaxWaste()
  317. {
  318.     return max_waste;
  319. }
  320.  
  321. //-----------------------------------------------------------------------------
  322. inline ADS_STRING& ADS_STRING::operator = ( const ADS_STRING& src)
  323. {
  324.     return Assign( src, 0, NPOS );
  325. }
  326.  
  327. //-----------------------------------------------------------------------------
  328. inline ADS_STRING& ADS_STRING::Assign( const ADS_STRING  &src )
  329. {
  330.     return Assign( src, 0, NPOS );
  331. }
  332.  
  333. //-----------------------------------------------------------------------------
  334. inline const char * ADS_STRING::CString() const
  335. {
  336.     return p->array;
  337. }
  338.  
  339. //-----------------------------------------------------------------------------
  340. inline void ADS_STRING::CopyOnWrite()
  341. {
  342.     if ( p->References() > 1 )
  343.     {
  344.         Clone();
  345.     }
  346. }
  347.  
  348. //-----------------------------------------------------------------------------
  349. inline BOOL ADS_STRING::Valid()
  350. {
  351.     return p != NULL;
  352. }
  353.  
  354. //-----------------------------------------------------------------------------
  355. inline size_t ADS_STRING::Length() const
  356. {
  357.     return p->nchars;
  358. }
  359.  
  360. //-----------------------------------------------------------------------------
  361. inline char& ADS_STRING::operator[]( size_t pos )
  362. {
  363.     return (*this)(pos);    // use operator()
  364. }
  365.  
  366. //-----------------------------------------------------------------------------
  367. inline char& ADS_STRING::operator()( size_t pos )
  368. {
  369.     return p->array[pos];
  370. }
  371.  
  372. //-----------------------------------------------------------------------------
  373. inline ADS_STRING& ADS_STRING::operator += ( const ADS_STRING &src )
  374. {
  375.     return Append( src, 0, NPOS );
  376. }
  377.  
  378. //-----------------------------------------------------------------------------
  379. inline ADS_STRING& ADS_STRING::operator += ( const char *cp )
  380. {
  381.     return Append( cp, 0, strlen(cp) );
  382. }
  383.  
  384. //-----------------------------------------------------------------------------
  385. inline ADS_STRING& ADS_STRING::Append( const ADS_STRING   &s )
  386. {
  387.     return Append(s, 0, NPOS);
  388. }
  389.  
  390. //-----------------------------------------------------------------------------
  391. inline ADS_STRING& ADS_STRING::Append( const char   *cp )
  392. {
  393.     return Append( cp, 0, strlen(cp) );
  394. }
  395. //-----------------------------------------------------------------------------
  396. inline void ADS_STRING::Clone()
  397. {
  398.     p->RemoveReference();
  399.     p = new STRING_REF( CString(), Length(), 0, 0, 0 );
  400. }
  401.  
  402. //-----------------------------------------------------------------------------
  403. //  friends...
  404. //
  405. //-----------------------------------------------------------------------------
  406. inline int operator == ( const ADS_STRING &s1, const ADS_STRING &s2 )
  407. {
  408.     return s1.Compare( s2 ) == 0;
  409. }
  410.  
  411. //-----------------------------------------------------------------------------
  412. inline int operator == ( const ADS_STRING& s1, const char *s2 )
  413. {
  414.     return s1.Compare( s2 ) == 0;
  415. }
  416.  
  417. //-----------------------------------------------------------------------------
  418. inline int operator == ( const char  *cp, const ADS_STRING  &s )
  419. {
  420.     return ADS_STRING( cp ).Compare( s ) == 0;
  421. }
  422.  
  423. //-----------------------------------------------------------------------------
  424. inline ADS_STRING operator + ( const ADS_STRING& s, const char *cp )
  425. {
  426.     return ADS_STRING( s, cp );
  427. }
  428.  
  429. //-----------------------------------------------------------------------------
  430. inline ADS_STRING operator + ( const ADS_STRING &s1, const ADS_STRING &s2 )
  431. {
  432.     return s1 + s2.CString();
  433. }
  434.  
  435. //-----------------------------------------------------------------------------
  436. inline ostream& operator << ( ostream &os, const ADS_STRING &s )
  437. {
  438.     return os << s.CString();
  439. }
  440.  
  441. //-----------------------------------------------------------------------------
  442. inline STRING_REF::~STRING_REF()
  443. {
  444.     delete array;
  445. }
  446.  
  447. #endif
  448.